Conversin a CPC:

1.- Lo primero que hago son los grficos y tal. Las conversiones
son las siguientes:

a) Para el spriteset, pongo todos los sprites de 8x16 seguidos en
un archivo, y luego escribo la paleta que uso en la configuracin
Img2CPC.exe.config. Tambin pongo el color de mscara.

Los convierto con:

$ Img2CPC.exe /w=8 /h=16 /bn=spr_ /m=0 /o=workspr.h spriteset.png

No voy a usar mscaras porque me da igual desperdiciar un color en
modo 0. Para modo 1, el archivo de sprites debera tener las mscaras
intercaladas y luego habra que llamar a arrangespr.exe para obtener
los sprites reordenados en tempspr.h

Con esto obtengo tempsr.h que copio a /dev/spriteset.h

Lo que s tengo que hacer es cambiar los punteros externos generados
de spriteset.h para que apunten a la cabecera y no a los datos de los
sprites:

extern unsigned char spr_0 [];
extern unsigned char spr_1 [];
extern unsigned char spr_2 [];
extern unsigned char spr_3 [];
extern unsigned char spr_4 [];
extern unsigned char spr_5 [];
extern unsigned char spr_6 [];
extern unsigned char spr_7 [];
extern unsigned char spr_8 [];
extern unsigned char spr_9 [];
extern unsigned char spr_10 [];
extern unsigned char spr_11 [];
extern unsigned char spr_12 [];
extern unsigned char spr_13 [];
extern unsigned char spr_14 [];
extern unsigned char spr_15 [];
extern unsigned char spr_16 [];
extern unsigned char spr_17 [];
extern unsigned char spr_18 [];
extern unsigned char spr_19 [];
extern unsigned char spr_20 [];

Tambin borro unsigned char *tiles []  que no sirve pa n.

b) Para el tileset, los pongo reordenados como siempre (por caracter
de 4x8) en tileset.png y lo convierto con:

$ Img2CPC.exe /w=4 /h=8 /bn=tile_ /m=0 /o=tilesetwork.h tileset.png

Luego los recorto y los meto en tilemapconf.asm, al final, y no
me olvido de sustituir la linea que define el tamao de cada tile por
"NADA" para eliminarlos.

c) Dibujo ttulo/marco, lo salvo en BMP. Abro ConvImgCPC y edito
la paleta. De camino apunto los nmeros:

0, 1, 2, 11, 23, 26, 25, 15, 7, 6, 4, 3, 13, 9, 21, 16

Luego los tendr que convertir a colores firmware para meter en el gego.

Abro el marco.bmp, marco todos los colores de la paltea, lo convierto y
lo guardo como marco.scr.

Este archivo tiene una cabecera AMSDOS que tengo que quitar. Ejecuto
striphd.exe (cutre como l solo) y escribo "marco" para abrirlo.

Comprimo el marco con exomizer:

$ exo marco.bin ..\dev\marcoc.exo

d) Cojo los niveles de Sir Ababol (mapa+enems), level0.bin y level1.bin,
y los comprimo con exomizer:

$ exo level0.bin ..\dev\level0c.exo
$ exo level1.bin ..\dev\level1c.exo

e) Revisando tilemapconf.asm (pillado del Cheril CPC) me doy cuenta de que
los buffers empiezan en $100 y ocupan 9600 bytes, por eso compilaba en la
direccin 10000. Voy a dejar 2220 bytes para descomprimir los niveles, por
lo que los niveles se descomprimen en 10000 y mi binario deber empezar en
12220. 

En 9700 dejo 300 bytes ah sueltos para usarlos si los necesito (por ejemplo,
podra mover los buffers de pantalla ah si es necesario).

f) Ahora empiezo a convertir el cdigo. Primero toda la inicializacin.
Abro ababol2.c para empezar. Me guo con chbcpc.c, la conversin que hicimos
en 2010 de Cheril of the Bosque, porque va en el mismo modo y usa la misma
configuracin de pantalla.

#include <cpcrslib.h>				// Biblioteca de juego por Artaburu.
#include <cpcwyzlib.h>				// Replayer AY por WYZ, adaptado por Artaburu.
//#include "sound.h"					// Configuracin del replayer AY.

(sound.h lo descomentar/har luego, por ahora voy a dejar esto funcionando
aunque sea sin sonido).

f2) Cambiar importacin de los grficos:

// Graphics
#include "spriteset.h"

f3) Cambiar pantalla comprimida en pantalla.h

g) En definitions.h, quito las definiciones de splib2 y pongo las de CPCRSLIB:

// (CPC)

struct sprite { 			// estructura mnima para usar la librera de dibujar sprites capturando el fondo.
	int sp0;				// 2 bytes	01
	int sp1;				// 2 bytes	23
	int coord0; 			// 2 bytes	45	 posicin en superbuffer
	int coord1; 			// 2 bytes	67	 posicin anterior en superbuffer
	unsigned char cx, cy;	// 2 bytes	89	 coordenadas nuevas
	unsigned char ox, oy;	// 2 bytes	AB	 coordenadas actuales
	unsigned char move; 	// 1 byte	 C	  si NO es 0, el sprite se mueve.
	unsigned char move1;	// 1 byte	 D	  si NO es 0, el sprite se mueve.
	// Si es 8 en cuanto se mueva se pone a 0 y ya no se mueve ms hasta nueva orden.
};

struct sprite sp_player;
struct sprite sp_enem1;
struct sprite sp_enem2;
struct sprite sp_enem3;

extern unsigned char tile_0 []; // Tiles en tilemapconf

// EOFCPC

Tambin aado las teclas:

#define KEY_IZQ 		0
#define KEY_DER 		1
#define KEY_ARR 		2
#define KEY_SAL 		3
#define KEY_FIR 		4
#define KEY_ESC 		5

Y quitamos los malloc y dems cosas.

Tambin hay que poner explcitamente "signed" todas las variables
globales que no lo tengan puesto.

h) En mysystem.h voy a poner las funciones y definiciones que necesito
especficas de CPC:

h1) Tintas:

	
	/*
	Tabla de conversin de paletas
	
	firm	hard
	0		20
	1		4
	2		21
	3		28
	4		24
	5		29
	6		12
	7		5
	8		13
	9		22
	10		6
	11		23
	12		30
	13		0
	14		31
	15		14
	16		7
	17		15
	18		18
	19		2
	20		19
	21		26
	22		25
	23		27
	24		10
	25		3
	26		11
	*/
	
unsigned char my_inks [] = {
	20, 4, 21, 23, 27, 11, 3, 14,
	5, 12, 24, 28, 0, 22, 26, 7
};
void set_inks () {
	unsigned char i;
	for (i = 0; i < 16; i ++)
		cpc_SetColour (i, my_inks [i]);
}

h2) Interrupciones:

void halt_me (void) {
	#asm
		halt				;unas esperas para que se actualicen los colores
		halt
		halt
		halt
		halt
	#endasm
}

void interrupciones(void) {
	// Manejador de interrupciones por Artaburu
	#asm
		di
		ld hl,($0039)
		ld (_int_original),HL   //guardo el salto original

		ld HL,_interrupcion
		ld ($0039),HL
		ei
		jp term
	._int_original  
		defw 0
	._interrupcion
		ei
		ret
	.term
	#endasm
}

h3) void init_cpcrslib_system () llama a estas cosas para inicializar.
Tambin llamar a wyz player, pero eso an no.

void init_cpcrslib_system () {
	interrupciones ();
	halt_me ();

	set_inks ();
	halt_me ();
	cpc_SetMode (0);
		
	// Inicializamos el player de wyz:
	
	//cpc_WyzInitPlayer (wyz_sound_table, wyz_pattern_table, wyz_effects_table, wyz_song_table);
	
	// Batera por el canal C
	
	//cpc_WyzConfigurePlayer (0);		
	
	// Ponemos el buffer en un sitio adecuado:
	
	//cpc_WyzSetBuffer (0xA500);
	
	// Borde 
	
	cpc_SetColour (16, 20);

	// Redefinimos las teclas
	
	cpc_AssignKey (KEY_IZQ, 0x4820);		// A
	cpc_AssignKey (KEY_DER, 0x4720);		// D
	cpc_AssignKey (KEY_ARR, 0x4708);		// W
	cpc_AssignKey (KEY_SAL, 0x4440);		// M
	cpc_AssignKey (KEY_FIR, 0x4540);		// N
	cpc_AssignKey (KEY_ESC, 0x4804);		// ESC
}

i1) En ababol2.c, cambiamos el bucle principal para usar CPCRSLIB. Esto
descomprime el ttulo y wait_a_bit la pulsacin de una tecla. Por ahora, dejamos
comentado las llamadas al player...

Si te fijas, antes se descomprime la cancin en 0xB400. Esta direccin apunta a
una reserva de algo ms de 3Kb al final de la RAM, justo antes de la pantalla
(que est en 0xC000). Nosotros tendremos las canciones comprimidas con exomizer
y las descomprimiremos en ese rea. El player est configurado para que todas
las canciones las cargue justo de ah. As "lo timamos" y podemos usar canciones
comprimidas.

Si al final ves que tu MUS ms grande ocupa menos de 3Kb, puedes subir 0xB400
ms arriba y dejar libre ms RAM para tu gego.

		cpc_UnExo ((unsigned int *) (s_title), (unsigned int *) (0xc000));
		
		//cpc_UnExo ((unsigned int *) (song_0), (unsigned int *) (0xB400));
		//cpc_WyzLoadSong (0);
		//cpc_WyzSetPlayerOn ();
		
		espera_activa (32767);
		
		//cpc_WyzSetPlayerOff ();
		
i2) Tambin dejamos comentado en el sitio correcto (bucle principal) la llamada a cargar y tocar la msica ingame,
as como pararla despus.

			/ Poner msica ingame
			//cpc_UnExo ((unsigned int *) (song_1), (unsigned int *) (0xB400));
			//cpc_WyzLoadSong (1);
			//cpc_WyzSetPlayerOn ();
			
			it = game ();
			
			// Parar msica ingame
			//cpc_WyzSetPlayerOff ();

i3) En mysystem.h, aadimos la inicializacin de sprites:

void init_sprites () {
	// Initialize CPCRSLIB sprites
	
	sp_player.sp0 = (int) (spr_0);
	sp_player.sp1 = (int) (spr_0);
	sp_player.move = 0;
	sp_player.cx = sp_player.ox = (player.x >> 6) >> 2;
	sp_player.cy = sp_player.oy = (player.y >> 6);
	
	sp_enem1.sp0 = (int) (spr_8);
	sp_enem1.sp1 = (int) (spr_8);
	sp_enem1.move = 0;
	sp_enem1.cx = sp_enem1.ox = 0;
	sp_enem1.cy = sp_enem1.oy = 0;
	
	sp_enem2.sp0 = (int) (spr_8);
	sp_enem2.sp1 = (int) (spr_8);
	sp_enem2.move = 0;
	sp_enem2.cx = sp_enem2.ox = 0;
	sp_enem2.cy = sp_enem2.oy = 0;
	
	sp_enem3.sp0 = (int) (spr_8);
	sp_enem3.sp1 = (int) (spr_8);
	sp_enem3.move = 0;
	sp_enem3.cx = sp_enem3.ox = 0;
	sp_enem3.cy = sp_enem3.oy = 0;
	
	sp_sword.sp0 = (int) (spr_8);
	sp_sword.sp1 = (int) (spr_8);
	sp_sword.move = 0;
	sp_sword.cx = sp_sword.ox = 0;
	sp_sword.cy = sp_sword.oy = 0;
}

Hay que mover la llamada a esta funcin al sitio correcto, justo
antes de empezar el bucle de juego, en engine.h (game)

	load_level ();	
	init_game ();
	init_sprites ();
				
j) Vamos a adaptar la descompresin de niveles y el dibujado de las
pantallas. Abrimos levelmanager.h

j1) Direcciones. El BUFFER en CPC est en 10000, lo ponemos ah:

#define BUFFER 10000

j2) Niveles comprimidos, son level0c.exo y level1c.exo:

// Compressed levels
// Levels are map + enems, compressed.
extern unsigned char clevel0 [0];
extern unsigned char clevel1 [0];
#asm
	._clevel0
		BINARY "level0c.exo"
	._clevel1
		BINARY "level1c.exo"
#endasm
unsigned char *clevels [] = {
	clevel0, clevel1
};

j3) Llamada a descomprimir:

void load_level () {
	// Unpack level
	cpc_UnExo ((unsigned int *) clevels [level], (unsigned int *) (BUFFER));
}

j4) Inicializacin de sprites enemigos. Cada sprite en CPC ocupa 66 bytes,
y no usan mscara (modo 0). Con este valor puedo calcular cualquier frame...
Multiplico por 132 para saltarme un frame, of cors.

Los sprites son:
8, 9: enemigo tipo 1
10, 11: enemigo tipo 2
12, 13: enemigo tipo 3
14, 15: enemigo tipo 4
16: explosin
17: vaco
19, 20, 21: espada

j5) Aadimos el reseteado del tilemap al terminar de pintar la pantalla:

	cpc_ResetTouchedTiles ();	
	cpc_ShowTileMap (0);

k) Modificamos rutinas de impresin de tiles de printer.h

k1) Cambiamos draw_map_tile para que use CPCRSLIB. Usamos sencillas 
llamadsa a cpc_SetTile:

void draw_map_tile (unsigned char x, unsigned char y, unsigned char t) {
	if (t == 0) {
		if (y >= 5) {
			tl_y = y - 5;
			t = backdrop [x + (tl_y << 4) - tl_y];
		}
	}
	if (t == 0 && (rand () & 15) == 1) t = 18;
	
	st_index = 64 + (t << 2);
	x = (x << 1);
	y = (y << 1);
	
	cpc_SetTile (x, y, st_index ++);
	cpc_SetTile (x + 1, y, st_index ++);
	cpc_SetTile (x, y + 1, st_index ++);
	cpc_SetTile (x + 1, y + 1, st_index);
}

Hay que crear otra que imprima los tiles invalidados. La original se usa
para pintar la pantalla, y la de tiles invalidados en cualquier otro caso:

void draw_map_tile_inv (unsigned char x, unsigned char y, unsigned char t) {
	if (t == 0) {
		if (y >= 5) {
			tl_y = y - 5;
			t = backdrop [x + (tl_y << 4) - tl_y];
		}
	}
	if (t == 0 && (rand () & 15) == 1) t = 18;
	
	st_index = 64 + (t << 2);
	x = (x << 1);
	y = (y << 1);
	
	cpc_SetTouchTileXY (x, y, st_index ++);
	cpc_SetTouchTileXY (x + 1, y, st_index ++);
	cpc_SetTouchTileXY (x, y + 1, st_index ++);
	cpc_SetTouchTileXY (x + 1, y + 1, st_index);
}

k2) Cambiamos print_number2 y print_number3. Como estas rutinas imprimen,
por lo general, fuera del rea tileada del juego, hay que usar llamadas a
cpc_PutTile2x8 y recordar que el primer tile est apuntado por tile_0.

Aqu, las coordenadas X van en bytes y las Y en pixels. Hay que ajustar
32 pixels (4 bytes) horizontalmente y 4 pxels verticalmente. Las coordenadas
en caracter hay que multiplicarlas por 2 horizontalmente (1 char = 2 bytes)
y por 8 verticalmente (1 char = 8 pxels).

Recordar, para los clculos, que cada tile ocupa 16 bytes.

Por cosas de esta versin de CPCRSLIB, el puntero es unsigned int *, y las
coordenadas unsigned char *...

void print_number2 (unsigned char x, unsigned char y, unsigned char number) {
	cpc_PutTile2x8 (
		(unsigned int *) (tile_0 + ((16 + (number / 10)) << 4)),
		(unsigned char *) (8 + (x << 1)),
		(unsigned char *) (4 + (y << 3))
	);
	
	cpc_PutTile2x8 (
		(unsigned int *) (tile_0 + ((16 + (number % 10)) << 4)),
		(unsigned char *) (8 + (x << 1) + 2),
		(unsigned char *) (4 + (y << 3))
	);
}

void print_number3 (unsigned char x, unsigned char y, unsigned char number) {
	sp_PrintAtInv (y, x, 5, 16 + (number / 100));
	sp_PrintAtInv (y, x + 1, 5, 16 + ((number % 100) / 10));
	sp_PrintAtInv (y, x + 2, 5, 16 + (number % 10));
	
	cpc_PutTile2x8 (
		(unsigned int *) (tile_0 + ((16 + (number / 100)) << 4)),
		(unsigned char *) (8 + (x << 1)),
		(unsigned char *) (4 + (y << 3))
	);
	
	cpc_PutTile2x8 (
		(unsigned int *) (tile_0 + ((16 + ((number % 100) / 10)) << 4)),
		(unsigned char *) (8 + (x << 1) + 2),
		(unsigned char *) (4 + (y << 3))
	);
	
	cpc_PutTile2x8 (
		(unsigned int *) (tile_0 + ((16 + (number % 10)) << 4)),
		(unsigned char *) (8 + (x << 1) + 4),
		(unsigned char *) (4 + (y << 3))
	);
}

k3) De la misma forma, cambiamos la rutina que imprime textos, con lo
mismo en mente...

void print_str (unsigned char x, unsigned char y, unsigned char c, unsigned char *s) {
	while (*s)	{
		cpc_PutTile2x8 (
			(unsigned int *) (tile_0 + ((*s ++) << 4)),
			(unsigned char *) (8 + (x << 1) + 4),
			(unsigned char *) (4 + (y << 3))
		);
		x ++;
	}
}

k4) La de blackout_area la hacemos as:
void blackout_area (void) {
	gpx = gpy = 0;
	for (it = 0; it < 150; it ++) {
		draw_map_tile (gpx, gpy, 0);
		gpx ++;
		if (gpx == 15) {
			gpy ++;
			gpx = 0;
		}
	}
	cpc_ResetTouchedTiles ();	
	cpc_ShowTileMap (0);
}


l) Modificamos algunas rutinas auxiliares en basio.h

void __FASTCALL__ wnokey (unsigned int key) {
	while (cpc_TestKey (key));	
}

char wait_a_bit (int espera) {
	// Waits until "espera" halts have passed 
	// or a key has been pressed.
	sp_WaitForNoKey ();
	for (it = 0; it < espera; it ++) {
		jt = 250; do { gpc = 1; } while (--jt);
		if (cpc_AnyKeyPressed ()) return 0;
	}
	return 1;
}

m) Ahora viene lo ms complicado: modificar los movimientos de
sprites y el render del bucle principal, as como las pulsaciones
de teclas... Abrimos engine.h

m0) Comento todos los peta_el_beeper !!

m1) Sprites!

m1.1) La espada, en render_sword. La vamos a quitar de aqu y la
vamos a mover al bucle principal. Aqu slo la movemos, quitamos la
llamada a splib y listo.

m1.2) El render del bucle principal. La actualizacin de los sprites
en el tilemap tiene su castaa, y hay que cambiar bastantes cosas.
Primero hay que actualizar los sprites, luego se actualiza el tilemap,
luego se vuelcan los sprites al tilemap, y luego se muestra por pantalla.

		// Render
		if (s_on) render_sword ();
		
		if (p_state == EST_PARP) {
			if (half_life)
				p_next_frame = spr_17;
			p_counter --;
			if (p_counter == 0)
				p_state = EST_NORMAL;	
		}
		
		sp_player.sp0 = (int) (p_next_frame);
		sp_player.cx = player.x >> 8;
		sp_player.cy = player.y >> 6;
		
		if (malotes [enoffs].t < 6) {
			px = malotes [enoffs].x >> 2;
			py = malotes [enoffs].y;
		} else {
			px = en_an_x [0] >> 8;	
			py = en_an_y [0] >> 6;
		}
		sp_enem1.sp0 = (int) (en_an_next_frame [0]);
		sp_enem1.cx = px;
		sp_enem1.cy = py;	
	
		if (malotes [enoffs + 1].t < 6) {
			px = malotes [enoffs + 1].x >> 2;
			py = malotes [enoffs + 1].y;
		} else {
			px = en_an_x [1] >> 8;	
			py = en_an_y [1] >> 6;
		}
		sp_enem2.sp0 = (int) (en_an_next_frame [1]);
		sp_enem2.cx = px;
		sp_enem2.cy = py;
		
		if (malotes [enoffs + 2].t < 6) {
			px = malotes [enoffs + 2].x >> 2;
			py = malotes [enoffs + 2].y;
		} else {
			px = en_an_x [2] >> 8;	
			py = en_an_y [2] >> 6;
		}
		sp_enem3.sp0 = (int) (en_an_next_frame [2]);
		sp_enem3.cx = px;
		sp_enem3.cy = py;	
		
		if (s_on) {
			sp_sword.sp0 = (int) (s_next_frame);
			sp_sword.cx = s_x >> 2;
			sp_sword.cy = s_yy;
		
			cpc_PutSpTileMap ((int) (sp_sword));
		}
		cpc_PutSpTileMap ((int) (sp_player));
		cpc_PutSpTileMap ((int) (sp_enem1));
		cpc_PutSpTileMap ((int) (sp_enem2));
		cpc_PutSpTileMap ((int) (sp_enem3));
		
		cpc_UpdScr ();
		
		// Mode 0
		if (s_on) {
			cpc_PutTrSp8x16TileMap2b ((int) (sp_sword));
		}
		cpc_PutTrSp8x16TileMap2b ((int) (sp_player));
		cpc_PutTrSp8x16TileMap2b ((int) (sp_enem1));
		cpc_PutTrSp8x16TileMap2b ((int) (sp_enem2));
		cpc_PutTrSp8x16TileMap2b ((int) (sp_enem3));
		
		// Update		
		cpc_ShowTouchedTiles ();
		cpc_ResetTouchedTiles ();
		
m1.3) Modificamos los frames de Sir Ababol...

// 0 1 2 3 + facing: walk, 1 = stand. 8 + facing = jump/fall
unsigned char *player_frames [] = {
	spr_0, spr_1, spr_2, spr_1,
	spr_4, spr_5, spr_6, spr_5,
	spr_3, spr_7
};

m1.4) Quitamos la parte al final del bucle principal que quita
los sprites de la pantalla, no es necesario aqu.

m2) Las teclas...
cpc_TestKey (KEY_ARR), etc... en "move"

m3) Ojo! Hay un problema que es fcil de resolver. Todo el display
de sprites est alineado a bytes. Cada byte equivale a 2 ladrillos, o
a 4 pxels virtuales (de la versin Spectrum). Para que lo que vemos y
la lgica sean consistentes, hay que ajustar el valor horizontal de
nuestro jugador a bytes de cuando en cuando: al saltar, y al no
pulsar izq/der...

m3.1) Salto:

	if (cpc_TestKey (KEY_ARR) && p_saltando == 0 && possee) {
		p_saltando = 1;
		p_cont_salto = 0;
		//peta_el_beeper (1);
		p_x = (p_x >> 8) << 8;
	}

m3.2) Al parar de movernos horizontalmente:
	if ( ! (cpc_TestKey (KEY_IZQ) || cpc_TestKey (KEY_DER)))
		if (p_vx > 0) {
			p_vx -= prx;
			if (p_vx < 0) {
				p_x = (p_x >> 8) << 8;
				p_vx = 0;
			}
		} else if (p_vx < 0) {
			p_vx += prx;
			if (p_vx > 0){
				p_x = (p_x >> 8) << 8;
				p_vx = 0;
			}
		}
		
m3.3) Cambiamos el clculo de frame de los enemigos:
		
n) Cruzamos los dedos e intentamos compilar...

zcc +cpc TileMapConf-sa2.asm -create-app -O3 -unsigned -o ababol2a.bin ababol2a.c -lcpcrslib -lcpcwyzlib -zorg=12220

o) Para probar, hay que copiar el BIN en la carpeta de WinApe y cargarlo.
Supongo que habr otra forma mejor, pero esta es la que yo me s.

Se pulsa F3 y se escribe:

org 12220
nolist
incbin "ababol2a.bin"

Y se pulsa F9 (run).

Luego se hace un call 12220 desde BASIC para ejecutar

BIEN

p) Ahora es cuando vamos a meter el sonido. Pillamos las msicas y los
efectos y los preparamos:

p1) Msicas: vamos a pillar "ingame1" y "title" de la versin de 128K. Cogemos
los .mus y los comprimimos con exomizer. Lo copiamos todo a /dev

Tambin pillamos un .mus.asm, y los efectos. Luego los usaremos en sound.h, en
el siguiente paso.

p2) Necesitamos crear un sound.h que cargue las canciones, defina los patrones
(instrumentos), efectos (batera) y efectos de sonido. Voy a coger la de Cheril
y la voy a adaptar a las msicas murcianas. Todo lo que necesito est en el 
.mus.asm que me pill y en efectos.asm...

q) Descomentamos la inicializacin del player en mysystem.h

	// Inicializamos el player de wyz:
	
	cpc_WyzInitPlayer (wyz_sound_table, wyz_pattern_table, wyz_effects_table, wyz_song_table);
	
	// Batera por el canal B
	
	cpc_WyzConfigurePlayer (1);		
	
r) Descomentamos las llamadas a cargar/tocar msicas de antes.

s) Llegados a este punto, probamos. El player siempre se me peliagudiza y mejor
ir pasito a pasito...	

t) Vamos a colocar las llamadas para los efectos de sonido. Estas van todas en
engine.h, y hay que tener paciencia porque son un montn...

Buscamos los peta_el_beeper comentados, y ah vamos colocando llamadas a la
funcin cpc_WyzStartEffect (WYZ_CANAL_EFECTOS, n);

Aprovechamos para definir WYZ_CANAL_EFECTOS en definitions.h

u) Anju va y se da cuenta de que la CPCRSLIB (al menos la versin vieja que
funciona con z88dk) no soporta clipping, as que tengo que modificar el render
de la espada para que nunca se salga de la pantalla.

	// CPC: cuidao con salirse!!
	if (s_x < 0) s_x = 0;
	if (s_x > 224) s_x = 224;
	if (s_y < 0) s_y = 0;

v) Sartar en la corshoneta.

w) Seguro que murcianow tiene algn cambio musical.

x, y, z) Habr que pulir algunas aristas, pero FIN!